home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / OpenGL / space / matrix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  5.4 KB  |  159 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. #include "space.h"
  18.  
  19. extern t_stopwatch Counter;
  20.  
  21. /**********************************************************************
  22. *  spLookMatrix()  - 
  23. **********************************************************************/
  24. void spLookMatrix(flot32 vx,flot32 vy,flot32 vz,flot32 px,flot32 py,flot32 pz,Matrix m)
  25.  
  26. {  flot32  sine,cosi,hyp,hyp1,dx,dy,dz;
  27.    Matrix  fat,mat ;
  28.  
  29.    dx = px - vx;
  30.    dy = py - vy;
  31.    dz = pz - vz;
  32.  
  33.    hyp = dx*dx + dz*dz;    /* hyp squared  */
  34.    hyp1 = fsqrt(dy*dy + hyp);
  35.    hyp = fsqrt(hyp);           /* the real hyp */
  36.  
  37.    if (hyp1 != 0.0) {          /* rotate X     */
  38.      sine = -dy / hyp1;
  39.      cosi = hyp / hyp1;
  40.      }
  41.    else {
  42.      sine = 0.0;
  43.      cosi = 1.0;
  44.      }
  45.  
  46.    mat[0][0] = 1.0; mat[0][1] =   0.0; mat[0][2] =  0.0; mat[0][3] = 0.0;
  47.    mat[1][0] = 0.0; mat[1][1] =  cosi; mat[1][2] = sine; mat[1][3] = 0.0;
  48.    mat[2][0] = 0.0; mat[2][1] = -sine; mat[2][2] = cosi; mat[2][3] = 0.0;
  49.    mat[3][0] = 0.0; mat[3][1] =   0.0; mat[3][2] =  0.0; mat[3][3] = 1.0;
  50.  
  51.    if (hyp != 0.0) {           /* rotate Y     */
  52.      sine = dx / hyp;
  53.      cosi = -dz / hyp;
  54.      }
  55.    else {
  56.      sine = 0.0;
  57.      cosi = 1.0;
  58.      }
  59.  
  60.    fat[0][0] = cosi; fat[0][1] = 0.0; fat[0][2] = -sine; fat[0][3] = 0.0;
  61.    fat[1][0] =  0.0; fat[1][1] = 1.0; fat[1][2] =   0.0; fat[1][3] = 0.0;
  62.    fat[2][0] = sine; fat[2][1] = 0.0; fat[2][2] =  cosi; fat[2][3] = 0.0;
  63.    fat[3][0] =  0.0; fat[3][1] = 0.0; fat[3][2] =   0.0; fat[3][3] = 1.0;
  64.  
  65.    spMultMatrix((flot32 *)m,(flot32 *)fat,(flot32 *)mat);
  66. }
  67.  
  68. /********************************************************************** 
  69. *  spTranMatrix()  -  
  70. **********************************************************************/
  71. void spTranMatrix(flot32 *mo,flot32 *mi)
  72.  
  73. {  Matrix mm ;
  74.    flot32 *ms ;
  75.    sint32 flag=0 ;
  76.  
  77.    if (mo == mi)  {
  78.      ms = mo ;
  79.      mo = &mm[0][0] ;
  80.      flag = 1 ;
  81.      }
  82.  
  83.    *(mo+ 0) = *(mi+ 0); *(mo+ 1) = *(mi+ 4); *(mo+ 2) = *(mi+ 8); *(mo+ 3) = *(mi+12);
  84.    *(mo+ 4) = *(mi+ 1); *(mo+ 5) = *(mi+ 5); *(mo+ 6) = *(mi+ 9); *(mo+ 7) = *(mi+13);
  85.    *(mo+ 8) = *(mi+ 2); *(mo+ 9) = *(mi+ 6); *(mo+10) = *(mi+10); *(mo+11) = *(mi+14);
  86.    *(mo+12) = *(mi+ 3); *(mo+13) = *(mi+ 7); *(mo+14) = *(mi+11); *(mo+15) = *(mi+15);
  87.  
  88.    if (flag) 
  89.      spCopyMatrix(ms,mo) ;
  90. }
  91.  
  92. /********************************************************************** 
  93. *  spCopyMatrix()  -  
  94. **********************************************************************/
  95. void spCopyMatrix(flot32 *mo,flot32 *mi)
  96.  
  97. {
  98.    *(mo+ 0) = *(mi+ 0); *(mo+ 1) = *(mi+ 1); *(mo+ 2) = *(mi+ 2); *(mo+ 3) = *(mi+ 3);
  99.    *(mo+ 4) = *(mi+ 4); *(mo+ 5) = *(mi+ 5); *(mo+ 6) = *(mi+ 6); *(mo+ 7) = *(mi+ 7);
  100.    *(mo+ 8) = *(mi+ 8); *(mo+ 9) = *(mi+ 9); *(mo+10) = *(mi+10); *(mo+11) = *(mi+11);
  101.    *(mo+12) = *(mi+12); *(mo+13) = *(mi+13); *(mo+14) = *(mi+14); *(mo+15) = *(mi+15);
  102. }
  103.  
  104. /********************************************************************** 
  105. *  spMultMatrix()  -  
  106. **********************************************************************/
  107. void spMultMatrix(flot32 *mo,flot32 *m1,flot32 *m2)
  108.  
  109. {  Matrix mm ;
  110.    flot32 *ms ;
  111.    sint32 flag=0 ;
  112.  
  113.    if (mo == m1 || mo == m2)  {
  114.      ms = mo ;
  115.      mo = (float *)mm ;
  116.      flag = 1 ;
  117.      }
  118.  
  119.    *(mo+ 0) = *(m1+ 0) * *(m2+ 0) + *(m1+ 1) * *(m2+ 4) + *(m1+ 2) * *(m2+ 8) ; 
  120.    *(mo+ 1) = *(m1+ 0) * *(m2+ 1) + *(m1+ 1) * *(m2+ 5) + *(m1+ 2) * *(m2+ 9) ;
  121.    *(mo+ 2) = *(m1+ 0) * *(m2+ 2) + *(m1+ 1) * *(m2+ 6) + *(m1+ 2) * *(m2+10) ;
  122.    *(mo+ 3) = 0.0 ;
  123.    *(mo+ 4) = *(m1+ 4) * *(m2+ 0) + *(m1+ 5) * *(m2+ 4) + *(m1+ 6) * *(m2+ 8) ;
  124.    *(mo+ 5) = *(m1+ 4) * *(m2+ 1) + *(m1+ 5) * *(m2+ 5) + *(m1+ 6) * *(m2+ 9) ;
  125.    *(mo+ 6) = *(m1+ 4) * *(m2+ 2) + *(m1+ 5) * *(m2+ 6) + *(m1+ 6) * *(m2+10) ;
  126.    *(mo+ 7) = 0.0 ;
  127.    *(mo+ 8) = *(m1+ 8) * *(m2+ 0) + *(m1+ 9) * *(m2+ 4) + *(m1+10) * *(m2+ 8) ; 
  128.    *(mo+ 9) = *(m1+ 8) * *(m2+ 1) + *(m1+ 9) * *(m2+ 5) + *(m1+10) * *(m2+ 9) ; 
  129.    *(mo+10) = *(m1+ 8) * *(m2+ 2) + *(m1+ 9) * *(m2+ 6) + *(m1+10) * *(m2+10) ; 
  130.    *(mo+11) = 0.0 ;
  131.    *(mo+12) = 0.0 ;
  132.    *(mo+13) = 0.0 ;
  133.    *(mo+14) = 0.0 ;
  134.    *(mo+15) = 1.0 ;
  135.  
  136.    if (flag) 
  137.      spCopyMatrix(ms,mo) ;
  138. }
  139.  
  140. /**********************************************************************
  141. *  spPerspMatrix()  - 
  142. **********************************************************************/
  143. void spPerspMatrix(flot32 min,flot32 max)
  144.  
  145. {  float  a,dz;
  146.    Matrix mt;
  147.  
  148.    dz = max - min;
  149.    a  = Counter.fov/Counter.aspcratio;
  150.  
  151.    mt[0][0] =   a; mt[0][1] =         0.0; mt[0][2] =             0.0; mt[0][3] =  0.0;
  152.    mt[1][0] = 0.0; mt[1][1] = Counter.fov; mt[1][2] =             0.0; mt[1][3] =  0.0;
  153.    mt[2][0] = 0.0; mt[2][1] =         0.0; mt[2][2] =   -(max+min)/dz; mt[2][3] = -1.0;
  154.    mt[3][0] = 0.0; mt[3][1] =         0.0; mt[3][2] = -2.0*min*max/dz; mt[3][3] =  1.0;
  155.  
  156.    glLoadMatrixf((float*)mt);
  157. }
  158.  
  159.